package com.example.typhoonproject.controller;

import com.example.typhoonproject.common.utils.Util;
import com.example.typhoonproject.entity.TyphoonNmcCnEntity;
import com.example.typhoonproject.service.TyphoonNmcCnService;
import com.example.typhoonproject.service.TyphoonPointService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

@RestController
@Slf4j
@RequestMapping("/typhoon")
@Api(value = "台风后端相关接口", tags = {"台风入库信息"})
public class TyphoonController {
    @Autowired
    private TyphoonPointService typhoonPointService;

    @Autowired
    private TyphoonNmcCnService typhoonNmcCnService;

    @Value("${dataConfig.csvFilPath}")
    private String csvFilPath;

    @GetMapping(value = "/insertTyphoon")
    @ApiOperation(value = "1.台风信息入库")
    public void getStationPre(){

    }

    public static void main(String[] args) {
        parsingTyMessage();
    }

    /**
     * 解析台风网报文
     */
    public static void parsingTyMessage(){

        // 指定要解析的目录路径
        String directoryPath = "D:\\remaps_data2\\TC_forecasttext";
        // 解析目录中的所有txt文件并获取解析结果
        List<TyphoonNmcCnEntity> parsedResults = parseTyphoonFiles(directoryPath);
        // 打印解析结果
        for (TyphoonNmcCnEntity result : parsedResults) {
            System.out.println(result);
        }
        // 台风网数据入库
        //typhoonNmcCnService.saveBatch(parsedResults);
    }

    /**
     * 解析指定目录中的所有txt文件
     * @param directoryPath 目录路径
     * @return 解析结果的列表
     */
    public static List<TyphoonNmcCnEntity> parseTyphoonFiles(String directoryPath) {
        List<TyphoonNmcCnEntity> results = new ArrayList<>();
        File directory = new File(directoryPath);

        // 检查目录是否存在且不为空
        if (directory.exists() && directory.isDirectory()) {
            File[] txtFiles = directory.listFiles((dir, name) -> name.endsWith(".txt"));

            if (txtFiles != null && txtFiles.length > 0) {
                for (File file : txtFiles) {
                    try {
                        // 解析文件并将结果添加到列表中
                        results.addAll(parseFile(file));
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } else {
                System.out.println("目录中没有找到txt文件。");
            }
        } else {
            System.out.println("目录不存在或为空。");
        }
        return results;
    }


    /**
     * 解析单个文件
     * @param file 文件对象
     * @return 解析结果的列表
     * @throws IOException
     */
    public static List<TyphoonNmcCnEntity> parseFile(File file) throws IOException {
        List<TyphoonNmcCnEntity> results = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
            String line;
            boolean parseNextLine = false; // 标志是否需要解析下一行

            TyphoonNmcCnEntity typhoonData = null;

            while ((line = reader.readLine()) != null) {
                // 检查当前行是否包含指定的关键词和台风编号
                if (containsTyphoonKeywords(line)) {
                    parseNextLine = true; // 设置标志解析下一行
                    typhoonData = parseFirstLine(line, file.getName()); // 解析当前行并创建 TyphoonData 对象
                } else if (parseNextLine && typhoonData != null) {
                    parseSecondLine(line, typhoonData); // 解析下一行并填充 TyphoonData 对象
                    results.add(typhoonData); // 将解析后的数据添加到结果列表中
                    parseNextLine = false; // 重置标志
                }
            }
        }
        return results;
    }

    /**
     * 检查行中是否包含指定的关键词和台风编号
     * @param line 要检查的行
     * @return 如果包含关键词和编号则返回true，否则返回false
     */
    public static boolean containsTyphoonKeywords(String line) {
        // 定义台风相关的关键词
        String[] keywords = {"TC:", "TD", "TS", "STS", "TY", "STY", "SuperTY"};
        for (String keyword : keywords) {
            // 检查行中是否包含关键词，并且是否包含括号内的编号格式
            if (line.contains(keyword) && line.matches(".*\\(\\d+\\).*")) {
                return true;
            }
        }
        return false;
    }

    /**
     * 解析包含台风信息的第一行
     * @param line 要解析的行
     * @return TyphoonData 对象
     */
    public static TyphoonNmcCnEntity parseFirstLine(String line, String fileName) {
        TyphoonNmcCnEntity typhoonData = new TyphoonNmcCnEntity();
        String[] parts = line.split("\\s+");
        typhoonData.setIntensity(parts[0]);// 台风强度
        typhoonData.setEnName(parts[1]); // 获取台风英文名
        //typhoonData.setCode(parts[2].substring(1, parts[2].length() - 1)); // 获取台风编号，去掉括号
        String typhoonCode = "20" + parts[2];
        typhoonData.setCode(typhoonCode); // 获取台风编号
        // 从文件名中提取时间并转换为UTC
        String dateTimeString = fileName.substring(0, fileName.length() - 4);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmm");
        LocalDateTime beijingTime = LocalDateTime.parse(dateTimeString, formatter);
        LocalDateTime utcTime = beijingTime.minusHours(8); // 北京时间转换为UTC时间

        // 获取YYYYMMDD部分
        String ymd = utcTime.format(DateTimeFormatter.ofPattern("yyyyMMdd"));

        // 获取DDHHmm部分
        String ddhhmm = parts[6];

        // 拼接完整的initialTime
        typhoonData.setInitialTime(ymd + ddhhmm);
        return typhoonData;
    }

    /**
     * 解析包含台风位置和强度的第二行
     * @param line 要解析的行
     * @param typhoonData 要填充的 TyphoonData 对象
     */
    public static void parseSecondLine(String line, TyphoonNmcCnEntity typhoonData) {
        String[] parts = line.split("\\s+");
        typhoonData.setLati(parseCoordinate(parts[1])); // 解析纬度
        typhoonData.setLoni(parseCoordinate(parts[2])); // 解析经度
        typhoonData.setEnpre(Double.parseDouble(parts[3].replace("HPA", "")) * 0.1); // 解析气压并转换单位
        typhoonData.setMaxwp(Double.parseDouble(parts[4].replace("M/S", "")) * 0.514); // 解析风速并转换单位
    }
    /**
     * 解析经纬度坐标
     * @param coordinate 要解析的坐标字符串
     * @return 解析后的坐标值
     */
    public static double parseCoordinate(String coordinate) {
        double value = Double.parseDouble(coordinate.substring(0, coordinate.length() - 1));
        return coordinate.endsWith("S") || coordinate.endsWith("W") ? -value : value;
    }


    private String convertDateFormat(String initialTime) {
        SimpleDateFormat inputFormat = new SimpleDateFormat("yyyyMMddHHmmss");
        SimpleDateFormat outputFormat = new SimpleDateFormat("yyyyMMdd_HHmm");
        try {
            Date date = inputFormat.parse(initialTime);
            return outputFormat.format(date);
        } catch (ParseException e) {
            log.error("日期格式转换错误: {}", e.getMessage());
            return null;
        }
    }
}
